{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "08 - API Gallery",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Pjmz-RORV8E"
      },
      "source": [
        "# API Gallery\n",
        "\n",
        "_This notebook is part of a tutorial series on [txtai](https://github.com/neuml/txtai), an AI-powered semantic search platform._\n",
        "\n",
        "The txtai API is a web-based service backed by [FastAPI](https://fastapi.tiangolo.com/). All txtai functionality including similarity search, extractive QA and zero-shot labeling is available via the API.\n",
        "\n",
        "This notebook installs the txtai API and shows an example using each of the supported language bindings for txtai."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dk31rbYjSTYm"
      },
      "source": [
        "# Install dependencies\n",
        "\n",
        "Install `txtai` and all dependencies. Since this notebook uses the API, we need to install the api extras package."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XMQuuun2R06J"
      },
      "source": [
        "%%capture\n",
        "!pip install git+https://github.com/neuml/txtai#egg=txtai[api]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-vGR_piwZZO6"
      },
      "source": [
        "# Python\n",
        "\n",
        "The first method we'll try is direct access via Python. We'll use zero-shot labeling for all the examples here. See [this notebook](https://colab.research.google.com/github/neuml/txtai/blob/master/examples/07_Apply_labels_with_zero_shot_classification.ipynb) for more details on zero-shot classification. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P4q72tkRMMkR"
      },
      "source": [
        "## Configure Labels instance"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Dy_TJ0iM38Q"
      },
      "source": [
        "%%capture\n",
        "import os\n",
        "from IPython.core.display import display, HTML\n",
        "from txtai.pipeline import Labels\n",
        "\n",
        "def table(rows):\n",
        "    html = \"\"\"\n",
        "    <style type='text/css'>\n",
        "    @import url('https://fonts.googleapis.com/css?family=Oswald&display=swap');\n",
        "    table {\n",
        "      border-collapse: collapse;\n",
        "      width: 900px;\n",
        "    }\n",
        "    th, td {\n",
        "        border: 1px solid #9e9e9e;\n",
        "        padding: 10px;\n",
        "        font: 20px Oswald;\n",
        "    }\n",
        "    </style>\n",
        "    \"\"\"\n",
        "\n",
        "    html += \"<table><thead><tr><th>Text</th><th>Label</th></tr></thead>\"\n",
        "    for text, label in rows:\n",
        "        html += \"<tr><td>%s</td><td>%s</td></tr>\" % (text, label)\n",
        "    html += \"</table>\"\n",
        "\n",
        "    display(HTML(html))\n",
        "\n",
        "# Create labels model\n",
        "labels = Labels()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L4B73tGkMT6Q"
      },
      "source": [
        "## Apply labels to text"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 324
        },
        "id": "-K2YJJzsVtfq",
        "outputId": "65782fd8-51fb-4531-8e8b-f28bca678fa0"
      },
      "source": [
        "data = [\"Wears a red suit and says ho ho\",\n",
        "        \"Pulls a flying sleigh\",\n",
        "        \"This is cut down and decorated\",\n",
        "        \"Santa puts these under the tree\",\n",
        "        \"Best way to spend the holidays\"]\n",
        "\n",
        "# List of labels\n",
        "tags = [\"🎅 Santa Clause\", \"🦌 Reindeer\", \"🍪 Cookies\", \"🎄 Christmas Tree\", \"🎁 Gifts\", \"👪 Family\"]\n",
        "\n",
        "# Render output to table\n",
        "table([(text, tags[labels(text, tags)[0][0]]) for text in data])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "    <style type='text/css'>\n",
              "    @import url('https://fonts.googleapis.com/css?family=Oswald&display=swap');\n",
              "    table {\n",
              "      border-collapse: collapse;\n",
              "      width: 900px;\n",
              "    }\n",
              "    th, td {\n",
              "        border: 1px solid #9e9e9e;\n",
              "        padding: 10px;\n",
              "        font: 20px Oswald;\n",
              "    }\n",
              "    </style>\n",
              "    <table><thead><tr><th>Text</th><th>Label</th></tr></thead><tr><td>Wears a red suit and says ho ho</td><td>🎅 Santa Clause</td></tr><tr><td>Pulls a flying sleigh</td><td>🦌 Reindeer</td></tr><tr><td>This is cut down and decorated</td><td>🎄 Christmas Tree</td></tr><tr><td>Santa puts these under the tree</td><td>🎁 Gifts</td></tr><tr><td>Best way to spend the holidays</td><td>👪 Family</td></tr></table>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UF_bImkLHTMs"
      },
      "source": [
        "Once again we see the power of zero-shot labeling. The model wasn't trained on any data specific to this example. Still amazed with how much knowledge is stored in large NLP models."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PNPJ95cdTKSS"
      },
      "source": [
        "# Start an API instance\n",
        "\n",
        "Now we'll start an API instance to run the remaining examples. The API needs a configuration file to run. The example below is simplified to only include labeling. See [this link](https://github.com/neuml/txtai#api) for a more detailed configuration example.\n",
        "\n",
        "The API instance is started in the background.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nTDwXOUeTH2-",
        "outputId": "2220a3c9-1cff-4c2f-b21e-13dd2d7cb816"
      },
      "source": [
        "%%writefile index.yml\n",
        "\n",
        "# Labels settings\n",
        "labels:"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing index.yml\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nGITHxUyRzyp"
      },
      "source": [
        "!CONFIG=index.yml nohup uvicorn \"txtai.api:app\" &> api.log &\n",
        "!sleep 90"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NHvBFZeSd9AG"
      },
      "source": [
        "# JavaScript\n",
        "\n",
        "txtai.js is available via NPM and can be installed as follows.\n",
        "\n",
        "```bash\n",
        "npm install txtai\n",
        "```\n",
        "\n",
        "For this example, we'll clone the txtai.js project to import the example build configuration."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b52knObEdcCr"
      },
      "source": [
        "%%capture\n",
        "!git clone https://github.com/neuml/txtai.js"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rUGS0t-JMsS9"
      },
      "source": [
        "## Create labels.js\n",
        "\n",
        "The following file is a JavaScript version of the labels example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zJbKRTSJV-kd",
        "outputId": "6c111b5d-6e55-4dac-c6c2-0988c2a834da"
      },
      "source": [
        "%%writefile txtai.js/examples/node/src/labels.js\n",
        "import {Labels} from \"txtai\";\n",
        "import {sprintf} from \"sprintf-js\";\n",
        "\n",
        "const run = async () => {\n",
        "    try {\n",
        "        let labels = new Labels(\"http://localhost:8000\");\n",
        "\n",
        "        let data = [\"Wears a red suit and says ho ho\",\n",
        "                    \"Pulls a flying sleigh\",\n",
        "                    \"This is cut down and decorated\",\n",
        "                    \"Santa puts these under the tree\",\n",
        "                    \"Best way to spend the holidays\"];\n",
        "\n",
        "        // List of labels\n",
        "        let tags = [\"🎅 Santa Clause\", \"🦌 Reindeer\", \"🍪 Cookies\", \"🎄 Christmas Tree\", \"🎁 Gifts\", \"👪 Family\"];\n",
        "\n",
        "        console.log(sprintf(\"%-40s %s\", \"Text\", \"Label\"));\n",
        "        console.log(\"-\".repeat(75))\n",
        "\n",
        "        for (let text of data) {\n",
        "            let label = await labels.label(text, tags);\n",
        "            label = tags[label[0].id];\n",
        "\n",
        "            console.log(sprintf(\"%-40s %s\", text, label));\n",
        "        }\n",
        "    }\n",
        "    catch (e) {\n",
        "        console.trace(e);\n",
        "    }\n",
        "};\n",
        "\n",
        "run();\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting txtai.js/examples/node/src/labels.js\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nTBs11j-GtD-"
      },
      "source": [
        "## Build and run labels example\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kC5Oub6wa1nK"
      },
      "source": [
        "%%capture\n",
        "os.chdir(\"txtai.js/examples/node\")\n",
        "!npm install\n",
        "!npm run build"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ckOHNqyaeL-B",
        "outputId": "6d8e745c-52d1-4456-fc46-2ff8fda2e675"
      },
      "source": [
        "!node dist/labels.js"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Text                                     Label\n",
            "---------------------------------------------------------------------------\n",
            "Wears a red suit and says ho ho          🎅 Santa Clause\n",
            "Pulls a flying sleigh                    🦌 Reindeer\n",
            "This is cut down and decorated           🎄 Christmas Tree\n",
            "Santa puts these under the tree          🎁 Gifts\n",
            "Best way to spend the holidays           👪 Family\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1yukBIMYG5OE"
      },
      "source": [
        "The JavaScript program is showing the same results as when natively running through Python!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nNiMgvg0p2BG"
      },
      "source": [
        "# Java\n",
        "\n",
        "txtai.java integrates with standard Java build tools (Gradle, Maven, SBT). The following shows how to add txtai as a dependency to Gradle.\n",
        "\n",
        "```gradle\n",
        "implementation 'com.github.neuml:txtai.java:v4.0.0'\n",
        "```\n",
        "\n",
        "For this example, we'll clone the txtai.java project to import the example build configuration."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qs2ai8lhqmga"
      },
      "source": [
        "%%capture\n",
        "os.chdir(\"/content\")\n",
        "!git clone https://github.com/neuml/txtai.java"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o8QFvzXkNFgq"
      },
      "source": [
        "## Create LabelsDemo.java\n",
        "\n",
        "The following file is a Java version of the labels example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v73L8Gw0p6fh",
        "outputId": "a7f797f2-a91f-4033-89c7-4baf76204d93"
      },
      "source": [
        "%%writefile txtai.java/examples/src/main/java/LabelsDemo.java\n",
        "import java.util.Arrays;\n",
        "import java.util.ArrayList;\n",
        "import java.util.List;\n",
        "\n",
        "import txtai.API.IndexResult;\n",
        "import txtai.Labels;\n",
        "\n",
        "public class LabelsDemo {\n",
        "    public static void main(String[] args) {\n",
        "        try {\n",
        "            Labels labels = new Labels(\"http://localhost:8000\");\n",
        "\n",
        "            List <String> data = \n",
        "                Arrays.asList(\"Wears a red suit and says ho ho\",\n",
        "                              \"Pulls a flying sleigh\",\n",
        "                              \"This is cut down and decorated\",\n",
        "                              \"Santa puts these under the tree\",\n",
        "                              \"Best way to spend the holidays\");\n",
        "\n",
        "            // List of labels\n",
        "            List<String> tags = Arrays.asList(\"🎅 Santa Clause\", \"🦌 Reindeer\", \"🍪 Cookies\", \"🎄 Christmas Tree\", \"🎁 Gifts\", \"👪 Family\");\n",
        "\n",
        "            System.out.printf(\"%-40s %s%n\", \"Text\", \"Label\");\n",
        "            System.out.println(new String(new char[75]).replace(\"\\0\", \"-\"));\n",
        "\n",
        "            for (String text: data) {\n",
        "                List<IndexResult> label = labels.label(text, tags);\n",
        "                System.out.printf(\"%-40s %s%n\", text, tags.get(label.get(0).id));\n",
        "            }\n",
        "        }\n",
        "        catch (Exception ex) {\n",
        "            ex.printStackTrace();\n",
        "        }\n",
        "    }\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting txtai.java/examples/src/main/java/LabelsDemo.java\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wZv7eMIOLnRC"
      },
      "source": [
        "## Build and run labels example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N2Mm3Gl5sH1z",
        "outputId": "b5249daf-e5a1-4b71-b64c-2b3c6748e846"
      },
      "source": [
        "os.chdir(\"txtai.java/examples\")\n",
        "!../gradlew -q --console=plain labels 2> /dev/null"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Text                                     Label\n",
            "---------------------------------------------------------------------------\n",
            "Wears a red suit and says ho ho          🎅 Santa Clause\n",
            "Pulls a flying sleigh                    🦌 Reindeer\n",
            "This is cut down and decorated           🎄 Christmas Tree\n",
            "Santa puts these under the tree          🎁 Gifts\n",
            "Best way to spend the holidays           👪 Family\n",
            "\u001b[m"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iHpQvUAgNp7j"
      },
      "source": [
        "The Java program is showing the same results as when natively running through Python!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zU6jK2UL7D5H"
      },
      "source": [
        "# Rust\n",
        "\n",
        "txtai.rs is available via crates.io and can be installed by adding the following to your cargo.toml file.\n",
        "\n",
        "```toml\n",
        "[dependencies]\n",
        "txtai = { version = \"4.0\" }\n",
        "tokio = { version = \"0.2\", features = [\"full\"] }\n",
        "```\n",
        "\n",
        "For this example, we'll clone the txtai.rs project to import the example build configuration. First we need to install Rust."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ob4aswkx7jRh"
      },
      "source": [
        "%%capture\n",
        "os.chdir(\"/content\")\n",
        "!apt-get install rustc\n",
        "!git clone https://github.com/neuml/txtai.rs"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "evEQQXBuObZn"
      },
      "source": [
        "## Create labels.rs\n",
        "\n",
        "The following file is a Rust version of the labels example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jjggKnKQ7jQO",
        "outputId": "76a2b1d9-2889-47b0-a3af-5d71a763bb0b"
      },
      "source": [
        "%%writefile txtai.rs/examples/demo/src/labels.rs\n",
        "use std::error::Error;\n",
        "\n",
        "use txtai::labels::Labels;\n",
        "\n",
        "pub async fn labels() -> Result<(), Box<dyn Error>> {\n",
        "    let labels = Labels::new(\"http://localhost:8000\");\n",
        "\n",
        "    let data = [\"Wears a red suit and says ho ho\",\n",
        "                \"Pulls a flying sleigh\",\n",
        "                \"This is cut down and decorated\",\n",
        "                \"Santa puts these under the tree\",\n",
        "                \"Best way to spend the holidays\"];\n",
        "\n",
        "    println!(\"{:<40} {}\", \"Text\", \"Label\");\n",
        "    println!(\"{}\", \"-\".repeat(75));\n",
        "\n",
        "    for text in data.iter() {\n",
        "        let tags = vec![\"🎅 Santa Clause\", \"🦌 Reindeer\", \"🍪 Cookies\", \"🎄 Christmas Tree\", \"🎁 Gifts\", \"👪 Family\"];\n",
        "        let label = labels.label(text, &tags).await?[0].id;\n",
        "\n",
        "        println!(\"{:<40} {}\", text, tags[label]);\n",
        "    }\n",
        "\n",
        "    Ok(())\n",
        "}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting txtai.rs/examples/demo/src/labels.rs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gFFPZO8sQZC4"
      },
      "source": [
        "## Build and run labels example\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wuoAidGz9T4g"
      },
      "source": [
        "%%capture\n",
        "os.chdir(\"txtai.rs/examples/demo\")\n",
        "!cargo build"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-_v_FbL0-yPk",
        "outputId": "821333f5-5f90-4f89-c2eb-673c2e14e4fe"
      },
      "source": [
        "!cargo run labels"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[0m\u001b[0m\u001b[1m\u001b[32m    Finished\u001b[0m dev [unoptimized + debuginfo] target(s) in 0.07s\n",
            "\u001b[0m\u001b[0m\u001b[1m\u001b[32m     Running\u001b[0m `target/debug/demo labels`\n",
            "Text                                     Label\n",
            "---------------------------------------------------------------------------\n",
            "Wears a red suit and says ho ho          🎅 Santa Clause\n",
            "Pulls a flying sleigh                    🦌 Reindeer\n",
            "This is cut down and decorated           🎄 Christmas Tree\n",
            "Santa puts these under the tree          🎁 Gifts\n",
            "Best way to spend the holidays           👪 Family\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kDmS89TPS3kb"
      },
      "source": [
        "The Rust program is showing the same results as when natively running through Python!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ezznN4I8_CCQ"
      },
      "source": [
        "# Go\n",
        "\n",
        "txtai.go can be installed by adding the following import statement. When using modules, txtai.go will automatically be installed. Otherwise use `go get`.\n",
        "\n",
        "```golang\n",
        "import \"github.com/neuml/txtai.go\"\n",
        "```\n",
        "\n",
        "For this example, we'll create a standalone process for labeling. First we need to install Go."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b-b6fhLQ_DpQ"
      },
      "source": [
        "%%capture\n",
        "os.chdir(\"/content\")\n",
        "!apt install golang-go\n",
        "!go get \"github.com/neuml/txtai.go\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dw-I6jOGR6vA"
      },
      "source": [
        "## Create labels.go\n",
        "\n",
        "The following file is a Go version of the labels example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bLBJwkN4ANpi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "883ea7b2-2fbc-471c-e0bb-59ef5172a6a4"
      },
      "source": [
        "%%writefile labels.go\n",
        "package main\n",
        "\n",
        "import (\n",
        "\t\"fmt\"\n",
        "\t\"strings\"\n",
        "\t\"github.com/neuml/txtai.go\"\n",
        ")\n",
        "\n",
        "func main() {\n",
        "\tlabels := txtai.Labels(\"http://localhost:8000\")\n",
        "\n",
        "\tdata := []string{\"Wears a red suit and says ho ho\",\n",
        "                   \"Pulls a flying sleigh\",\n",
        "                   \"This is cut down and decorated\",\n",
        "                   \"Santa puts these under the tree\",\n",
        "                   \"Best way to spend the holidays\"}\n",
        "\n",
        "\t// List of labels\n",
        "\ttags := []string{\"🎅 Santa Clause\", \"🦌 Reindeer\", \"🍪 Cookies\", \"🎄 Christmas Tree\", \"🎁 Gifts\", \"👪 Family\"}\n",
        "\n",
        "\tfmt.Printf(\"%-40s %s\\n\", \"Text\", \"Label\")\n",
        "\tfmt.Println(strings.Repeat(\"-\", 75))\n",
        "\n",
        "\tfor _, text := range data {\n",
        "\t\tlabel := labels.Label(text, tags)\n",
        "\t\tfmt.Printf(\"%-40s %s\\n\", text, tags[label[0].Id])\n",
        "\t}\n",
        "}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing labels.go\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PJ2XzzDbSeZh"
      },
      "source": [
        "## Build and run labels example\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l1xnUbtdAy0p",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5bc6015c-5c9c-4d8a-daf7-6897ec6cbd80"
      },
      "source": [
        "!go run labels.go"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Text                                     Label\n",
            "---------------------------------------------------------------------------\n",
            "Wears a red suit and says ho ho          🎅 Santa Clause\n",
            "Pulls a flying sleigh                    🦌 Reindeer\n",
            "This is cut down and decorated           🎄 Christmas Tree\n",
            "Santa puts these under the tree          🎁 Gifts\n",
            "Best way to spend the holidays           👪 Family\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oml43X5eS6YB"
      },
      "source": [
        "The Go program is showing the same results as when natively running through Python!"
      ]
    }
  ]
}